type
    Ordering union {
        const L<R, L=R, L>R
    }

public operator
    == { a Ordering, b Ordering } Bool
    native('__UnionIndexEqual')

type ==[T] interface { Equal Lambda[Pair[T,T],Bool] }
type  <[T] interface { Compare Lambda[Pair[T,T],Bool] }
type <>[T] interface { Compare Lambda[Pair[T,T],Ordering] }

public operator
    !=[T] { a T, b T } { == ==[T] } Bool
    { not(==(a,b)) }

public operator
    >[T] { a T, b T } { < <[T] } Bool
    { <(b,a) }

public operator
    <=[T] { a T, b T } { < <[T] } Bool
    { not(<(b,a)) }

public operator
    >=[T] { a T, b T } { < <[T] } Bool
    { not(<(a,b)) }

public function
    Min[T] { a T, b T } { < <[T] } T
    { if (<(a,b)) { a } else { b } }

public function
    Max[T] { a T, b T } { < <[T] } T
    { if (<(b,a)) { a } else { b } }


